#include "Sql_list.h"


/** 初始化
 * 函数名 Init_Sql_List
 * 参数 
 *      @L 需要初始化的 静态表
 * 返回值
 *      无
 * 功能
 *      对静态表进行初始化
 */
void Init_Sql_List(Sql_list * L)
{
    // 对创建的数据做清空
    memset(L->data , 0 , 50 * sizeof(L->data[0]) );
    // 初始化表的长度 len
    L->len = 0;
}

/** 尾插
 * 函数名 tail_insert_list
 * 参数 
 *      @L 需要尾插的 静态表
 *      @data 需要插入的数据
 * 返回值
 *      无
 * 功能
 *      对静态表进行尾插
 */
void tail_insert_list(Sql_list * L  , Elenemt_data data)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return ;
    }
    if (MAX_SIZ <= L->len)
    {
        printf("顺序表 为 满 \n");
        return ;
    }

    // 插入
    L->data[L->len] = data;
    // 迭代
    L->len++;

}

/** 尾删
 * 函数名 tail_del_list
 * 参数 
 *      @L 需要尾删的 静态表
 * 返回值
 *      无
 * 功能
 *      对静态表进行尾删
 */
void tail_del_list(Sql_list * L )
{
    // 安排判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return ;
    }
    if (0 >= L->len)
    {
        printf("顺序表 内 无数据 \n");
        return ;
    }

    // memset(&L->data[L->len] , sizeof(L->data[0]) , 0);

    L->len--;

}

/** 遍历打印
 * 函数名 printf_Sql_List
 * 参数 
 *      @L 需要遍历的 静态表
 * 返回值
 *      无
 * 功能
 *      对静态表进行尾插
 */
void printf_Sql_List(Sql_list * L)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return ;
    }
    if (0 == L->len)
    {
        printf("顺序表 内 无数据 \n");
        return ;
    }

    for (size_t i = 0; i < L->len; i++)
    {
        printf("姓名:%s 性别:%s 年龄:%d 成绩:%d 学号:%d\n",
        L->data[i].name , L->data[i].sex , L->data[i].age , 
        L->data[i].sco  , L->data[i].id 
        );
    }

}


/** 判空
 * 函数名 IsEmpty_Sql_List
 * 参数 
 *      @L 需要判空的 静态表
 * 返回值
 *      0 代表 为 空
 *      1 代表 不为 空
 * 功能
 *    判断表是否为空  
 *      
 */
int IsEmpty_Sql_List(Sql_list * L)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return 0;
    }

    if (0 >= L->len)
    {
        printf("IsEmpty_Sql_List : 表为空\n");
        return 0;
    }
    printf("IsEmpty_Sql_List : 表不为空\n");
    return 1;
}

/** 清空
 * 函数名 Clear_Sql_List
 * 参数 
 *      @L 需要清空的 静态表
 * 返回值
 *      无
 * 功能
 *      清空顺序表
 */
void Clear_Sql_List(Sql_list * L)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return ;
    }
    memset( L->data , 0 , MAX_SIZ * sizeof(L->data[0]));
    L->len = 0;
    
}

/** 任意位置插入
 * 函数名 pos_insert_list
 * 参数 
 *      @L 需要插入的 静态表
 *      @index 需要插入的位置
 *      @data 插入的数据
 * 返回值
 *      无
 * 功能
 *      任意位置插入
 */
void pos_insert_list(Sql_list * L , int pos , Elenemt_data data)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return ;
    }
    if (MAX_SIZ <= L->len)
    {
        printf("顺序表 为 满 \n");
        return ;
    }
    if ( L->len + 1 < pos )
    {
        printf("index 参数不合法 \n");
        return ;
    }
    
    // =================== 开始插入 ===================
    if (pos == L->len + 1)  // 尾插入
    {
        // 插入
        L->data[L->len] = data;
        // 迭代
        L->len++;
        return ;
    }
    // 中间插入
    
    for (size_t i = L->len; i >= pos; i--)
    {
        L->data[i] = L->data[i - 1];
    }
    /*
    条件 i = L->len  = 3
        pos = 1
    10 20 30
    第一次循环  i >= pos  条件满足  3 >= 1
        做一次交换   i--
    10 20 30 30
    第二次循环  i >= pos  条件满足  2 >= 1
        做二次交换   i--
    10 20 20 30
    第三次循环  i >= pos  条件满足  1 >= 1
        做三次交换   i--
    10 10 30 30
    */
    
    L->data[pos - 1] = data;
    L->len++;
    return ;
}

/** 任意位置删除
 * 函数名 pos_insert_list
 * 参数 
 *      @L 需要插入的 静态表
 *      @index 需要删除的位置
 * 返回值
 *      无
 * 功能
 *      任意位置删除
 */
void pos_del_list(Sql_list * L , int pos)
{
    // 安排判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return ;
    }
    if (0 >= L->len)
    {
        printf("顺序表 内 无数据 \n");
        return ;
    }
    if (pos > L->len)
    {
        printf("index 参数不合法 \n");
        return ;
    }
    

    // =================== 开始删除 ===================
    if (pos > L->len - 1) // 尾删
    {
        L->len--;
        return ;
    }

    for (size_t i = pos; i < L->len; i++) // 中间删除
    {
        L->data[i - 1] = L->data[i];
    }
    /*
    条件
        i = pos = 1
        L->len = 4
        10 20 30 40 
    第一次循环  条件满足 i < L->len    1  < 4
        20 20 30 40
    第二次循环  条件满足 i < L-s>len    2  < 4
        20 30 30 40
    第三次循环  条件满足 i < L-s>len    3  < 4
        20 30 40 40
    */
    
    L->len--;

    return ;
}


// 顺序表的合并：
Sql_list Merge_Sql_Lists(Sql_list * L1 , Sql_list * L2)
{
    Sql_list L3;
    Init_Sql_List(&L3);
    // 安全判断
    if (NULL == L1 || NULL == L1)
    {
        printf("顺序表 为 NULL \n");
        return L3;
    }
    if (MAX_SIZ < L1->len + L2->len )
    {
        printf("顺序表 有越界的风险 \n");
        return L3;
    }
    if (0 == L2->len)
    {
        printf("L2 中 无数据\n");
        return L3;
    }
    
    // 开始合并
        // 扩容方式1    返回值 类型为 void
    // for (size_t i = L1->len , j = 0; j < L2->len ; i++ , j++)
    // {
    //     L1->data[i] = L2->data[j];
    //     L1->len++;
    // }
        // 扩容方式2   返回值 类型为 void
    // printf("L1 = %p\n" , L1);
    // for (size_t i = 0; i < L2->len; i++)
    // {
    //     tail_insert_list(L1 , L2->data[i] );
    // }

        // 扩容方式3   返回值 类型为 Sql_list
    for (size_t i = 0; i < L1->len; i++)
    {
        tail_insert_list(&L3 , L1->data[i]);
    }
    for (size_t i = 0; i < L2->len; i++)
    {
        tail_insert_list(&L3 , L2->data[i]);
    }

    return L3;
}

// 顺序表的查找：

int find_by_name(Sql_list * L , char * name)
{
    // 安全判断
    if (NULL == L || NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return 0;
    }
    if (0 == L->len)
    {
        printf("顺序表 内 无数据\n");
        return 0;
    }

    // 第一种方式
    // for (size_t i = 0; i < L->len; i++)
    // {
    //     if (!strcmp(L->data[i].name , name))
    //     {
    //         printf("找到了 index = %ld\n" , i + 1);
    //         return i;
    //     }
    // }
    // printf("没找到了\n");
    // 第二种方式
    printf("请输入你需要查找的名字\n");
    char buf[128] = "张三";
    scanf("%s" , buf);
    for (size_t i = 0; i < L->len; i++)
    {
        if (!strcmp(L->data[i].name , buf))
        {
            printf("找到了 index = %ld\n" , i + 1);
            return i;
        }
    }
    printf("没找到了\n");
    return EOF;
    
}


